# -*- coding: utf-8 -*-
import sys
import os

# 设置UTF-8编码
if hasattr(sys.stdout, 'reconfigure'):
    sys.stdout.reconfigure(encoding='utf-8')
if hasattr(sys.stderr, 'reconfigure'):
    sys.stderr.reconfigure(encoding='utf-8')

# 设置环境变量确保中文支持
os.environ.setdefault('PYTHONIOENCODING', 'utf-8')
os.environ.setdefault('LANG', 'C.UTF-8')
os.environ.setdefault('LC_ALL', 'C.UTF-8')

import time
import json
import requests
import schedule
import threading
import redis
import nmap
import psutil
import pyclamd
import subprocess
from datetime import datetime
from flask import Flask, jsonify, request
from openai import OpenAI
from dotenv import load_dotenv

# 加载环境变量
load_dotenv()

app = Flask(__name__)
app.config['JSON_AS_ASCII'] = False
app.config['JSONIFY_MIMETYPE'] = 'application/json; charset=utf-8'

def json_response(data, status_code=200):
    """返回支持中文的JSON响应"""
    response = app.response_class(
        response=json.dumps(data, ensure_ascii=False, indent=2),
        status=status_code,
        mimetype='application/json; charset=utf-8'
    )
    return response

# Redis 连接
redis_client = redis.Redis(
    host=os.getenv('REDIS_HOST', 'localhost'),
    port=int(os.getenv('REDIS_PORT', 6379)),
    decode_responses=True
)

# 告警服务URL
ALARM_SERVICE_URL = os.getenv('ALARM_SERVICE_URL', 'http://localhost:23847')

# DeepSeek AI 客户端
deepseek_client = None
if os.getenv('ENABLE_AI_ANALYSIS', 'false').lower() == 'true':
    try:
        deepseek_client = OpenAI(
            api_key=os.getenv('DEEPSEEK_API_KEY'),
            base_url=os.getenv('DEEPSEEK_BASE_URL', 'https://api.deepseek.com')
        )
        print("✅ DeepSeek AI 客户端初始化成功")
    except Exception as e:
        print(f"❌ DeepSeek AI 客户端初始化失败: {e}")

class SecurityScanner:
    """增强版安全检测扫描器 - 集成ClamAV和AI分析"""
    
    def __init__(self):
        self.nm = nmap.PortScanner()
        self.scan_results = []
        self.clamd_client = None
        self.init_clamav()
    
    def init_clamav(self):
        """初始化ClamAV连接"""
        try:
            clamd_host = os.getenv('CLAMD_HOST', 'localhost')
            clamd_port = int(os.getenv('CLAMD_PORT', 3310))

            # 首先尝试网络连接
            try:
                self.clamd_client = pyclamd.ClamdNetworkSocket(host=clamd_host, port=clamd_port)
                if self.clamd_client.ping():
                    print(f"✅ ClamAV 网络连接成功 ({clamd_host}:{clamd_port})")
                    return
            except Exception as network_error:
                print(f"⚠️ ClamAV 网络连接失败: {network_error}")

            # 尝试Unix套接字连接
            try:
                clamd_socket = os.getenv('CLAMD_SOCKET', '/var/run/clamav/clamd.ctl')
                self.clamd_client = pyclamd.ClamdUnixSocket(path=clamd_socket)
                if self.clamd_client.ping():
                    print(f"✅ ClamAV Unix套接字连接成功 ({clamd_socket})")
                    return
            except Exception as socket_error:
                print(f"⚠️ ClamAV Unix套接字连接失败: {socket_error}")

            # 尝试启动ClamAV守护进程
            print("🔄 尝试启动ClamAV守护进程...")
            try:
                subprocess.run(['sudo', 'systemctl', 'start', 'clamav-daemon'], 
                             check=True, capture_output=True, text=True)
                time.sleep(3)  # 等待服务启动
                
                # 重新尝试连接
                self.clamd_client = pyclamd.ClamdNetworkSocket(host=clamd_host, port=clamd_port)
                if self.clamd_client.ping():
                    print(f"✅ ClamAV 守护进程启动成功，连接建立 ({clamd_host}:{clamd_port})")
                    return
            except subprocess.CalledProcessError as service_error:
                print(f"⚠️ 无法启动ClamAV守护进程: {service_error}")
            except Exception as restart_error:
                print(f"⚠️ 重启后连接失败: {restart_error}")

            print("❌ ClamAV 所有连接方式均失败，将在无ClamAV模式下运行")
            self.clamd_client = None

        except Exception as e:
            print(f"❌ ClamAV 初始化失败: {e}")
            self.clamd_client = None
    
    def update_virus_database(self):
        """更新病毒库"""
        try:
            print("🔄 开始更新ClamAV病毒库...")
            
            # 使用freshclam命令更新病毒库
            result = subprocess.run(['freshclam'], capture_output=True, text=True, timeout=300)
            
            if result.returncode == 0:
                print("✅ 病毒库更新成功")
                return True
            else:
                print(f"❌ 病毒库更新失败: {result.stderr}")
                return False
                
        except subprocess.TimeoutExpired:
            print("❌ 病毒库更新超时")
            return False
        except Exception as e:
            print(f"❌ 病毒库更新异常: {e}")
            return False
    
    def virus_scan(self):
        """病毒扫描"""
        if not self.clamd_client:
            print("❌ ClamAV 未连接，跳过病毒扫描")
            return []
        
        threats = []
        scan_dirs = os.getenv('SCAN_DIRECTORIES', '/tmp').split(',')
        
        try:
            print("🦠 开始病毒扫描...")
            
            for scan_dir in scan_dirs:
                scan_dir = scan_dir.strip()
                if not os.path.exists(scan_dir):
                    print(f"⚠️  扫描目录不存在: {scan_dir}")
                    continue
                
                print(f"🔍 扫描目录: {scan_dir}")
                
                try:
                    # 扫描目录
                    scan_result = self.clamd_client.multiscan_file(scan_dir)
                    
                    if scan_result:
                        for file_path, (status, virus_name) in scan_result.items():
                            if status == 'FOUND':
                                threat = {
                                    'type': '病毒检测',
                                    'level': '严重',
                                    'details': f'在文件 {file_path} 中发现病毒: {virus_name}',
                                    'source': '文件系统层面',
                                    'location': file_path,
                                    'scan_directory': scan_dir,
                                    'virus_name': virus_name,
                                    'file_path': file_path,
                                    'threat_category': '恶意软件',
                                    'impact': '可能导致系统感染、数据损坏或隐私泄露',
                                    'recommendation': f'立即隔离或删除感染文件 {file_path}，运行完整系统扫描，检查是否有其他感染文件'
                                }
                                threats.append(threat)
                                print(f"🚨 发现病毒: {file_path} -> {virus_name}")
                    
                except Exception as e:
                    print(f"❌ 扫描目录 {scan_dir} 失败: {e}")
                    continue
            
            if not threats:
                print("✅ 病毒扫描完成，未发现威胁")
            else:
                print(f"🚨 病毒扫描完成，发现 {len(threats)} 个威胁")
                
        except Exception as e:
            print(f"❌ 病毒扫描异常: {e}")
        
        return threats
    
    def port_scan(self, target_host='127.0.0.1', port_range='1-1000'):
        """端口扫描检测 - 提供具体服务信息和详细修复建议"""
        try:
            print(f"🔍 开始对 {target_host} 进行端口扫描...")
            self.nm.scan(target_host, port_range)
            
            threats = []
            current_dir = os.getcwd()
            
            for host in self.nm.all_hosts():
                for proto in self.nm[host].all_protocols():
                    ports = self.nm[host][proto].keys()
                    open_ports = [port for port in ports if self.nm[host][proto][port]['state'] == 'open']
                    
                    # 详细的端口风险分析，包含具体项目路径和配置文件
                    port_risks = {
                        22: {
                            'service': 'SSH', 'risk': '高', 'category': '系统服务',
                            'description': 'SSH远程登录服务，可能被暴力破解',
                            'config_file': '/etc/ssh/sshd_config',
                            'project_impact': '可能影响整个服务器安全',
                            'attack_vectors': ['暴力破解', '密钥泄露', '弱密码攻击'],
                            'detailed_recommendation': '''紧急安全加固措施：
1. 修改SSH配置文件 /etc/ssh/sshd_config：
   - 禁用root登录：PermitRootLogin no
   - 修改默认端口：Port 2222
   - 启用密钥认证：PubkeyAuthentication yes
   - 禁用密码认证：PasswordAuthentication no
2. 设置防火墙规则限制访问IP
3. 启用fail2ban防暴力破解
4. 定期检查登录日志：tail -f /var/log/auth.log
5. 使用强密钥对替代密码认证'''
                        },
                        23: {
                            'service': 'Telnet', 'risk': '严重', 'category': '系统服务',
                            'description': 'Telnet明文传输，极易被窃听',
                            'config_file': '/etc/inetd.conf',
                            'project_impact': '所有传输数据可被明文截获',
                            'attack_vectors': ['流量嗅探', '中间人攻击', '凭据窃取'],
                            'detailed_recommendation': '''立即禁用Telnet服务：
1. 停止telnet服务：sudo systemctl stop telnet
2. 禁用开机启动：sudo systemctl disable telnet
3. 卸载telnet服务器：sudo apt remove telnetd
4. 使用SSH替代Telnet进行远程管理
5. 检查网络流量是否存在明文传输'''
                        },
                        80: {
                            'service': 'HTTP', 'risk': '中', 'category': 'Web服务',
                            'description': 'HTTP Web服务，可能存在Web漏洞',
                            'config_file': f'{current_dir}/nginx.conf 或 /etc/nginx/nginx.conf',
                            'project_impact': f'可能影响项目 {current_dir} 的Web应用安全',
                            'attack_vectors': ['SQL注入', 'XSS攻击', 'CSRF攻击', '目录遍历'],
                            'detailed_recommendation': f'''Web服务安全加固：
1. 检查Web服务器配置文件：
   - Nginx: /etc/nginx/sites-available/default
   - Apache: /etc/apache2/sites-available/000-default.conf
2. 启用HTTPS重定向：
   server {{
       listen 80;
       return 301 https://$server_name$request_uri;
   }}
3. 隐藏服务器版本信息
4. 设置安全头部：X-Frame-Options, X-XSS-Protection
5. 定期更新Web应用框架和依赖
6. 部署Web应用防火墙(WAF)
7. 检查项目文件 {current_dir} 中的Web应用安全配置'''
                        },
                        443: {
                            'service': 'HTTPS', 'risk': '低', 'category': 'Web服务',
                            'description': 'HTTPS Web服务，相对安全但需关注证书',
                            'config_file': f'{current_dir}/ssl.conf 或 /etc/nginx/ssl.conf',
                            'project_impact': f'项目 {current_dir} 的HTTPS配置需要优化',
                            'attack_vectors': ['证书过期', '弱加密算法', 'SSL/TLS漏洞'],
                            'detailed_recommendation': f'''HTTPS安全优化：
1. 检查SSL证书状态：openssl x509 -in cert.pem -text -noout
2. 验证证书有效期：openssl x509 -in cert.pem -dates -noout
3. 配置强加密套件：
   ssl_protocols TLSv1.2 TLSv1.3;
   ssl_ciphers ECDHE-RSA-AES256-GCM-SHA512:DHE-RSA-AES256-GCM-SHA512;
4. 启用HSTS：add_header Strict-Transport-Security "max-age=31536000";
5. 定期更新SSL证书
6. 检查项目 {current_dir} 中的SSL配置文件'''
                        },
                        5432: {
                            'service': 'PostgreSQL', 'risk': '高', 'category': '数据库服务',
                            'description': 'PostgreSQL数据库，需要访问控制',
                            'config_file': '/etc/postgresql/*/main/postgresql.conf',
                            'project_impact': f'可能影响项目 {current_dir} 的数据库安全',
                            'attack_vectors': ['SQL注入', '弱密码', '权限提升', '数据泄露'],
                            'detailed_recommendation': f'''PostgreSQL安全加固：
1. 修改数据库配置文件 /etc/postgresql/*/main/postgresql.conf：
   - 限制监听地址：listen_addresses = 'localhost'
   - 启用SSL：ssl = on
2. 配置访问控制 /etc/postgresql/*/main/pg_hba.conf：
   - 禁用trust认证
   - 使用md5或scram-sha-256认证
3. 创建专用数据库用户，避免使用postgres超级用户
4. 定期备份数据库
5. 启用查询日志监控
6. 检查项目 {current_dir} 中的数据库连接配置
7. 使用连接池限制并发连接数'''
                        },
                        6379: {
                            'service': 'Redis', 'risk': '中', 'category': '缓存服务',
                            'description': 'Redis缓存服务，可能是项目组件',
                            'config_file': '/etc/redis/redis.conf',
                            'project_impact': f'项目 {current_dir} 的Redis缓存可能存在安全风险',
                            'attack_vectors': ['未授权访问', '命令注入', '数据泄露'],
                            'detailed_recommendation': f'''Redis安全配置：
1. 修改Redis配置文件 /etc/redis/redis.conf：
   - 设置密码：requirepass your_strong_password
   - 绑定本地地址：bind 127.0.0.1
   - 禁用危险命令：rename-command FLUSHDB ""
2. 启用持久化和备份
3. 设置内存限制：maxmemory 256mb
4. 启用日志记录：logfile /var/log/redis/redis-server.log
5. 检查项目 {current_dir} 中的Redis连接配置
6. 使用Redis ACL进行用户权限管理'''
                        },
                        19563: {
                            'service': 'DeepGuard Scanner', 'risk': '低', 'category': '安全服务',
                            'description': 'DeepGuard安全扫描服务',
                            'config_file': f'{current_dir}/security-modules/security-scanner/scanner.py',
                            'project_impact': f'DeepGuard项目 {current_dir} 的安全扫描服务',
                            'attack_vectors': ['服务暴露', 'API滥用'],
                            'detailed_recommendation': f'''DeepGuard服务安全优化：
1. 检查服务配置文件 {current_dir}/security-modules/security-scanner/scanner.py
2. 启用API访问控制和认证
3. 限制服务访问IP范围
4. 启用请求频率限制
5. 监控服务访问日志
6. 定期更新服务依赖包'''
                        },
                        23847: {
                            'service': 'DeepGuard Alarm', 'risk': '低', 'category': '告警服务',
                            'description': 'DeepGuard告警服务',
                            'config_file': f'{current_dir}/alarm-modules/alarm-service/app.py',
                            'project_impact': f'DeepGuard项目 {current_dir} 的告警服务',
                            'attack_vectors': ['告警绕过', '邮件伪造'],
                            'detailed_recommendation': f'''DeepGuard告警服务安全优化：
1. 检查告警服务配置 {current_dir}/alarm-modules/alarm-service/app.py
2. 启用SMTP认证和加密
3. 验证邮件发送者身份
4. 监控告警发送频率
5. 设置告警内容过滤规则'''
                        }
                    }
                    
                    for port in open_ports:
                        service_info = self.nm[host][proto][port]
                        service_name = service_info.get('name', 'unknown')
                        service_version = service_info.get('version', '')
                        
                        if port in port_risks:
                            risk_info = port_risks[port]
                        else:
                            # 未知端口的通用风险分析
                            risk_info = {
                                'service': service_name, 'risk': '中', 'category': '未知服务',
                                'description': f'发现未知服务 {service_name}',
                                'config_file': f'未知配置文件位置',
                                'project_impact': f'可能影响项目 {current_dir} 的安全',
                                'attack_vectors': ['未知攻击向量'],
                                'detailed_recommendation': f'''未知服务安全检查：
1. 识别服务用途和必要性
2. 检查服务配置和权限
3. 如非必要，建议关闭该服务
4. 监控服务访问日志
5. 定期更新服务版本'''
                            }
                        
                        threat = {
                            'type': f'{risk_info["category"]}端口风险 - {risk_info["service"]}',
                            'level': risk_info['risk'],
                            'details': f'在主机 {host} 端口 {port} 发现 {risk_info["service"]} 服务 (版本: {service_version or "未知"})',
                            'source': '系统网络层面',
                            'location': f'主机 {host}:{port}',
                            'port': port,
                            'service': risk_info['service'],
                            'service_version': service_version,
                            'category': risk_info['category'],
                            'config_file': risk_info['config_file'],
                            'project_impact': risk_info['project_impact'],
                            'attack_vectors': risk_info['attack_vectors'],
                            'vulnerability_details': risk_info['description'],
                            'recommendation': risk_info['detailed_recommendation'],
                            'urgency': '高' if risk_info['risk'] in ['高', '严重'] else '中',
                            'fix_time_estimate': '立即处理' if risk_info['risk'] == '严重' else '24小时内处理'
                        }
                        threats.append(threat)
            
            return threats
            
        except Exception as e:
            print(f"❌ 端口扫描失败: {e}")
            return []
    
    def system_resource_check(self):
        """系统资源检查 - 提供详细的系统状态和具体修复建议"""
        threats = []
        current_dir = os.getcwd()
        
        try:
            # CPU使用率检查
            cpu_percent = psutil.cpu_percent(interval=1)
            cpu_count = psutil.cpu_count()
            cpu_freq = psutil.cpu_freq()
            
            if cpu_percent > 90:
                threats.append({
                    'type': '系统CPU使用率严重异常',
                    'level': '高',
                    'details': f'系统CPU使用率达到 {cpu_percent:.1f}%，超过安全阈值90%，可能存在恶意进程、系统负载过高或资源耗尽攻击',
                    'source': '操作系统层面',
                    'location': f'系统全局 - {cpu_count}核心CPU',
                    'metric_value': f'{cpu_percent:.1f}%',
                    'cpu_cores': cpu_count,
                    'cpu_frequency': f'{cpu_freq.current:.0f}MHz' if cpu_freq else '未知',
                    'threshold': '90%',
                    'severity_analysis': '严重 - 可能导致系统响应缓慢或服务不可用',
                    'potential_causes': ['恶意挖矿程序', '死循环进程', 'DDoS攻击', '系统资源耗尽攻击', '配置错误的服务'],
                    'immediate_actions': [
                        '立即查看CPU占用最高的进程：top -o %CPU',
                        '检查系统负载：uptime',
                        '查看进程树：pstree -p',
                        '监控实时CPU使用：htop'
                    ],
                    'detailed_recommendation': f'''紧急CPU异常处理方案：
1. 立即诊断步骤：
   - 执行 top -o %CPU 查看CPU占用最高的进程
   - 执行 ps aux --sort=-%cpu | head -10 列出前10个高CPU进程
   - 检查系统负载：cat /proc/loadavg
   - 查看CPU核心使用情况：mpstat -P ALL 1

2. 进程分析和处理：
   - 识别异常进程的启动路径和参数
   - 检查进程是否为项目 {current_dir} 相关服务
   - 对于恶意进程：kill -9 <PID>
   - 对于系统服务：systemctl restart <service>

3. 系统优化措施：
   - 调整进程优先级：nice -n 19 <command>
   - 限制进程CPU使用：cpulimit -p <PID> -l 50
   - 检查定时任务：crontab -l
   - 清理临时文件：rm -rf /tmp/* /var/tmp/*

4. 长期监控方案：
   - 设置CPU使用率告警阈值
   - 部署系统监控工具（如Prometheus）
   - 定期检查系统性能基线
   - 建立进程白名单机制''',
                    'urgency': '紧急',
                    'fix_time_estimate': '立即处理',
                    'business_impact': '可能导致服务中断，影响用户访问'
                })
            
            # 内存使用率检查
            memory = psutil.virtual_memory()
            swap = psutil.swap_memory()
            
            if memory.percent > 90:
                threats.append({
                    'type': '系统内存使用率严重异常',
                    'level': '高',
                    'details': f'系统内存使用率达到 {memory.percent:.1f}%，可能存在内存泄漏、恶意程序或内存耗尽攻击',
                    'source': '操作系统层面',
                    'location': '系统全局内存',
                    'metric_value': f'{memory.percent:.1f}%',
                    'memory_total': f'{memory.total / (1024**3):.2f}GB',
                    'memory_used': f'{memory.used / (1024**3):.2f}GB',
                    'memory_available': f'{memory.available / (1024**3):.2f}GB',
                    'memory_free': f'{memory.free / (1024**3):.2f}GB',
                    'swap_total': f'{swap.total / (1024**3):.2f}GB',
                    'swap_used': f'{swap.used / (1024**3):.2f}GB',
                    'swap_percent': f'{swap.percent:.1f}%',
                    'threshold': '90%',
                    'severity_analysis': '严重 - 可能导致系统OOM杀死进程或系统崩溃',
                    'potential_causes': ['内存泄漏程序', '恶意内存消耗', '缓存过大', '数据库缓冲区配置错误'],
                    'detailed_recommendation': f'''内存异常紧急处理方案：
1. 立即内存诊断：
   - 查看内存占用：free -h
   - 按内存使用排序进程：ps aux --sort=-%mem | head -10
   - 检查内存详细信息：cat /proc/meminfo
   - 查看内存使用趋势：vmstat 1 5

2. 内存释放措施：
   - 清理系统缓存：echo 3 > /proc/sys/vm/drop_caches
   - 重启高内存占用的非关键服务
   - 检查项目 {current_dir} 中的应用内存使用
   - 临时增加swap空间：fallocate -l 2G /swapfile

3. 应用程序检查：
   - 检查Python应用内存泄漏：使用memory_profiler
   - 检查数据库内存配置
   - 监控Docker容器内存限制
   - 分析项目日志文件大小

4. 系统优化配置：
   - 调整vm.swappiness参数
   - 配置OOM killer策略
   - 设置内存使用限制：ulimit -m
   - 建立内存监控告警机制

5. 预防措施：
   - 定期重启内存密集型服务
   - 实施内存使用配额
   - 部署内存监控工具
   - 建立内存使用基线''',
                    'urgency': '紧急',
                    'fix_time_estimate': '立即处理',
                    'business_impact': '可能导致服务OOM崩溃，严重影响业务连续性'
                })
            
            # 磁盘使用率检查
            disk = psutil.disk_usage('/')
            disk_percent = (disk.used / disk.total) * 100
            
            # 检查多个重要分区
            important_paths = ['/', '/var', '/tmp', '/home', current_dir]
            for path in important_paths:
                if os.path.exists(path):
                    try:
                        path_disk = psutil.disk_usage(path)
                        path_percent = (path_disk.used / path_disk.total) * 100
                        
                        if path_percent > 95:
                            threats.append({
                                'type': f'磁盘空间严重不足 - {path}',
                                'level': '高' if path in ['/', '/var'] else '中',
                                'details': f'分区 {path} 磁盘使用率达到 {path_percent:.1f}%，可能影响系统正常运行或导致服务故障',
                                'source': '文件系统层面',
                                'location': f'磁盘分区 {path}',
                                'metric_value': f'{path_percent:.1f}%',
                                'disk_total': f'{path_disk.total / (1024**3):.2f}GB',
                                'disk_used': f'{path_disk.used / (1024**3):.2f}GB',
                                'disk_free': f'{path_disk.free / (1024**3):.2f}GB',
                                'threshold': '95%',
                                'partition_type': '系统关键分区' if path in ['/', '/var'] else '应用分区',
                                'severity_analysis': '严重 - 可能导致无法写入文件、日志丢失或服务崩溃',
                                'detailed_recommendation': f'''磁盘空间紧急清理方案：
1. 立即空间分析：
   - 查看分区使用情况：df -h {path}
   - 找出大文件：find {path} -type f -size +100M -exec ls -lh {{}} \\;
   - 分析目录大小：du -sh {path}/* | sort -hr
   - 检查inode使用：df -i {path}

2. 紧急清理措施：
   {"- 清理系统日志：journalctl --vacuum-time=7d" if path == "/" else ""}
   {"- 清理APT缓存：apt clean && apt autoclean" if path == "/" else ""}
   {"- 清理临时文件：rm -rf /tmp/* /var/tmp/*" if path in ["/", "/tmp", "/var"] else ""}
   - 清理项目日志：find {current_dir} -name "*.log" -mtime +7 -delete
   - 清理Docker镜像：docker system prune -a

3. 应用程序清理：
   {"- 检查项目文件：find " + current_dir + " -type f -size +50M" if path == current_dir else ""}
   - 清理数据库日志文件
   - 压缩或删除旧的备份文件
   - 清理应用程序缓存目录

4. 系统配置优化：
   - 配置日志轮转：/etc/logrotate.conf
   - 设置临时文件自动清理
   - 配置磁盘使用配额
   - 建立磁盘监控告警

5. 长期解决方案：
   - 扩展磁盘空间或添加新磁盘
   - 迁移大文件到其他存储
   - 实施数据归档策略
   - 部署分布式存储解决方案''',
                                'urgency': '紧急' if path in ['/', '/var'] else '高',
                                'fix_time_estimate': '立即处理',
                                'business_impact': '可能导致无法写入数据、服务崩溃或系统不稳定'
                            })
                    except Exception as e:
                        continue
            
            # 检查可疑进程 - 详细分析
            suspicious_processes = []
            high_cpu_processes = []
            high_memory_processes = []
            
            for proc in psutil.process_iter(['pid', 'name', 'cpu_percent', 'memory_percent', 'cmdline', 'create_time', 'username', 'cwd']):
                try:
                    proc_info = proc.info
                    if proc_info['cpu_percent'] > 50 or proc_info['memory_percent'] > 20:  # 高资源占用进程
                        cmdline = ' '.join(proc_info['cmdline'][:5]) if proc_info['cmdline'] else proc_info['name']
                        create_time = datetime.fromtimestamp(proc_info['create_time']).strftime('%Y-%m-%d %H:%M:%S')
                        
                        # 详细的进程分类
                        process_category = '未知进程'
                        risk_level = '中'
                        project_related = False
                        
                        if proc_info['cwd'] and current_dir in str(proc_info['cwd']):
                            project_related = True
                            process_category = f'项目相关进程 ({current_dir})'
                            risk_level = '低'
                        elif any(keyword in cmdline.lower() for keyword in ['python', 'scanner.py', 'app.py']):
                            process_category = 'Python应用进程'
                            if 'scanner.py' in cmdline or 'app.py' in cmdline:
                                project_related = True
                                process_category = 'DeepGuard服务进程'
                                risk_level = '低'
                        elif 'docker' in cmdline.lower():
                            process_category = 'Docker容器进程'
                            risk_level = '低'
                        elif any(keyword in cmdline.lower() for keyword in ['nginx', 'apache', 'httpd']):
                            process_category = 'Web服务器进程'
                            risk_level = '低'
                        elif any(keyword in cmdline.lower() for keyword in ['mysql', 'postgres', 'redis', 'mongo']):
                            process_category = '数据库服务进程'
                            risk_level = '低'
                        elif any(keyword in cmdline.lower() for keyword in ['ssh', 'sshd']):
                            process_category = '系统服务进程'
                            risk_level = '低'
                        elif any(suspicious in cmdline.lower() for suspicious in ['miner', 'crypto', 'bitcoin', 'xmrig', 'malware']):
                            process_category = '可疑恶意进程'
                            risk_level = '严重'
                        
                        process_detail = {
                            'name': proc_info['name'],
                            'pid': proc_info['pid'],
                            'cpu': proc_info['cpu_percent'],
                            'memory': proc_info['memory_percent'],
                            'cmdline': cmdline,
                            'create_time': create_time,
                            'username': proc_info['username'],
                            'cwd': proc_info['cwd'],
                            'category': process_category,
                            'risk_level': risk_level,
                            'project_related': project_related
                        }
                        
                        if proc_info['cpu_percent'] > 50:
                            high_cpu_processes.append(process_detail)
                        if proc_info['memory_percent'] > 20:
                            high_memory_processes.append(process_detail)
                        
                        if risk_level in ['高', '严重'] or (proc_info['cpu_percent'] > 80 and not project_related):
                            suspicious_processes.append(process_detail)
                        
                except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
                    continue
            
            # 报告可疑进程
            for proc_info in suspicious_processes[:5]:  # 报告前5个最可疑的进程
                threats.append({
                    'type': f'发现可疑高资源占用进程 - {proc_info["category"]}',
                    'level': proc_info['risk_level'],
                    'details': f'进程 {proc_info["name"]} (PID: {proc_info["pid"]}) 异常占用系统资源 - CPU: {proc_info["cpu"]:.1f}%, 内存: {proc_info["memory"]:.1f}%',
                    'source': '进程监控层面',
                    'location': f'进程ID {proc_info["pid"]} - 工作目录: {proc_info["cwd"] or "未知"}',
                    'process_name': proc_info['name'],
                    'process_id': proc_info['pid'],
                    'cpu_usage': f'{proc_info["cpu"]:.1f}%',
                    'memory_usage': f'{proc_info["memory"]:.1f}%',
                    'command_line': proc_info['cmdline'],
                    'start_time': proc_info['create_time'],
                    'process_user': proc_info['username'],
                    'working_directory': proc_info['cwd'],
                    'process_category': proc_info['category'],
                    'project_related': proc_info['project_related'],
                    'risk_assessment': '高风险' if proc_info['risk_level'] == '严重' else '中等风险',
                    'detailed_recommendation': f'''进程异常处理方案：
1. 进程详细分析：
   - 查看进程详情：ps -fp {proc_info["pid"]}
   - 检查进程文件：ls -la /proc/{proc_info["pid"]}/exe
   - 查看进程网络连接：netstat -p | grep {proc_info["pid"]}
   - 检查进程打开的文件：lsof -p {proc_info["pid"]}

2. 安全评估：
   - 进程分类：{proc_info["category"]}
   - 项目关联：{"是" if proc_info["project_related"] else "否"}
   - 启动时间：{proc_info["create_time"]}
   - 运行用户：{proc_info["username"]}

3. 处理建议：
   {"- 立即终止恶意进程：kill -9 " + str(proc_info["pid"]) if proc_info["risk_level"] == "严重" else ""}
   {"- 检查进程合法性，如确认安全可继续运行" if proc_info["project_related"] else ""}
   {"- 分析进程行为，确定是否为正常业务进程" if proc_info["risk_level"] == "中" else ""}
   - 监控进程资源使用趋势
   - 检查进程是否为系统必需服务

4. 预防措施：
   - 建立进程白名单机制
   - 设置资源使用限制
   - 部署进程行为监控
   - 定期进行进程安全审计''',
                    'urgency': '紧急' if proc_info['risk_level'] == '严重' else '高',
                    'fix_time_estimate': '立即处理' if proc_info['risk_level'] == '严重' else '1小时内处理',
                    'business_impact': '可能影响系统性能或存在安全风险'
                })
                
        except Exception as e:
            print(f"❌ 系统资源检查失败: {e}")
        
        return threats
    
    def simulate_sql_injection_check(self):
        """模拟SQL注入检测 - 提供具体文件路径和详细修复建议"""
        import random
        import os
        threats = []
        
        # 获取当前工作目录，用于生成具体的文件路径
        current_dir = os.getcwd()
        
        # 模拟不同项目中的SQL注入威胁，包含具体文件路径
        injection_scenarios = [
            {
                'type': 'SQL注入攻击 - 登录绕过',
                'level': '高',
                'details': f'在项目 {current_dir}/web-modules/user-auth/login.py 第45行发现SQL注入漏洞，攻击者尝试通过恶意SQL语句绕过身份验证',
                'source': 'Web应用程序层面',
                'location': f'{current_dir}/web-modules/user-auth/login.py:45',
                'project_path': f'{current_dir}/web-modules/user-auth/',
                'vulnerable_file': 'login.py',
                'line_number': 45,
                'attack_pattern': "' OR '1'='1' --",
                'vulnerability': '用户输入未经过滤直接拼接到SQL查询中',
                'vulnerable_code': 'query = f"SELECT * FROM users WHERE username=\'{username}\' AND password=\'{password}\'"',
                'impact': '攻击者可能获得未授权的系统访问权限，绕过登录验证',
                'recommendation': '''立即修复建议：
1. 将 login.py 第45行的字符串拼接改为参数化查询
2. 修复代码示例：
   # 危险代码（当前）
   query = f"SELECT * FROM users WHERE username='{username}' AND password='{password}'"
   
   # 安全代码（修复后）
   query = "SELECT * FROM users WHERE username=%s AND password=%s"
   cursor.execute(query, (username, password))
   
3. 对所有用户输入进行严格验证和转义
4. 实施输入长度限制和特殊字符过滤
5. 建议使用ORM框架如SQLAlchemy替代原生SQL'''
            },
            {
                'type': 'SQL注入攻击 - 数据泄露',
                'level': '严重',
                'details': f'在项目 {current_dir}/api-modules/user-service/user_query.py 第78行发现SQL注入漏洞，攻击者可能通过UNION查询获取敏感数据',
                'source': 'API服务层面',
                'location': f'{current_dir}/api-modules/user-service/user_query.py:78',
                'project_path': f'{current_dir}/api-modules/user-service/',
                'vulnerable_file': 'user_query.py',
                'line_number': 78,
                'attack_pattern': "' UNION SELECT username,password FROM users --",
                'vulnerability': '搜索功能存在SQL注入点，用户输入直接拼接到查询语句',
                'vulnerable_code': 'sql = f"SELECT id,name,email FROM users WHERE name LIKE \'%{search_term}%\'"',
                'impact': '可能导致用户密码、个人信息、财务数据等敏感信息泄露',
                'recommendation': '''紧急修复措施：
1. 立即修复 user_query.py 第78行的SQL注入漏洞
2. 修复代码示例：
   # 危险代码（当前）
   sql = f"SELECT id,name,email FROM users WHERE name LIKE '%{search_term}%'"
   
   # 安全代码（修复后）
   sql = "SELECT id,name,email FROM users WHERE name LIKE %s"
   cursor.execute(sql, (f'%{search_term}%',))
   
3. 实施数据库访问权限最小化原则
4. 启用数据库查询日志监控
5. 对敏感数据进行加密存储
6. 建议部署Web应用防火墙(WAF)进行实时防护'''
            },
            {
                'type': 'SQL注入攻击 - 盲注探测',
                'level': '中',
                'details': f'在项目 {current_dir}/search-modules/product-search/search.py 第123行检测到基于时间的盲注攻击尝试，攻击者正在探测数据库结构',
                'source': '搜索服务层面',
                'location': f'{current_dir}/search-modules/product-search/search.py:123',
                'project_path': f'{current_dir}/search-modules/product-search/',
                'vulnerable_file': 'search.py',
                'line_number': 123,
                'attack_pattern': "'; WAITFOR DELAY '00:00:05' --",
                'vulnerability': '搜索参数存在SQL注入漏洞，可被利用进行盲注攻击',
                'vulnerable_code': 'query = f"SELECT * FROM products WHERE category=\'{category}\' ORDER BY {sort_field}"',
                'impact': '攻击者可能逐步获取数据库结构、表名、字段名等敏感信息',
                'recommendation': '''修复建议：
1. 修复 search.py 第123行的参数化查询问题
2. 修复代码示例：
   # 危险代码（当前）
   query = f"SELECT * FROM products WHERE category='{category}' ORDER BY {sort_field}"
   
   # 安全代码（修复后）
   allowed_sort_fields = ['name', 'price', 'date']
   if sort_field not in allowed_sort_fields:
       sort_field = 'name'
   query = "SELECT * FROM products WHERE category=%s ORDER BY " + sort_field
   cursor.execute(query, (category,))
   
3. 实施白名单验证机制
4. 添加查询超时限制
5. 监控异常查询模式
6. 定期进行安全代码审计'''
            },
            {
                'type': 'SQL注入攻击 - 管理后台漏洞',
                'level': '严重',
                'details': f'在项目 {current_dir}/admin-modules/report-system/report.py 第67行发现SQL注入漏洞，影响管理员报表功能',
                'source': '管理后台系统',
                'location': f'{current_dir}/admin-modules/report-system/report.py:67',
                'project_path': f'{current_dir}/admin-modules/report-system/',
                'vulnerable_file': 'report.py',
                'line_number': 67,
                'attack_pattern': "'; DROP TABLE users; --",
                'vulnerability': '报表查询功能存在SQL注入，可能被利用执行任意SQL命令',
                'vulnerable_code': 'sql = f"SELECT * FROM orders WHERE date BETWEEN \'{start_date}\' AND \'{end_date}\'"',
                'impact': '攻击者可能删除数据库表、修改数据或获取管理员权限',
                'recommendation': '''高优先级修复：
1. 立即修复 report.py 第67行的SQL注入漏洞
2. 修复代码示例：
   # 危险代码（当前）
   sql = f"SELECT * FROM orders WHERE date BETWEEN '{start_date}' AND '{end_date}'"
   
   # 安全代码（修复后）
   sql = "SELECT * FROM orders WHERE date BETWEEN %s AND %s"
   cursor.execute(sql, (start_date, end_date))
   
3. 对管理后台实施额外的访问控制
4. 启用数据库操作审计日志
5. 实施数据库备份和恢复策略
6. 考虑使用只读数据库用户进行查询操作'''
            }
        ]
        
        if random.random() < 0.6:  # 60%概率检测到威胁，增加检测概率
            selected_scenario = random.choice(injection_scenarios)
            threats.append(selected_scenario)
        
        return threats
    
    def ai_analyze_threats(self, threats):
        """使用AI智能分析威胁"""
        if not deepseek_client or not threats:
            return threats
        
        try:
            print("🤖 开始AI威胁分析...")
            
            # 构建分析提示
            threats_summary = "\n".join([
                f"- {threat['type']}: {threat['details']}" 
                for threat in threats
            ])
            
            system_prompt = """你是一个资深的网络安全专家，拥有丰富的威胁分析经验。请深度分析以下检测到的安全威胁。

<think>
我需要仔细分析每个威胁的特征、潜在影响和风险等级。让我逐一分析：

1. 首先识别威胁类型和严重程度
2. 分析可能的攻击路径和影响范围  
3. 评估业务风险和技术风险
4. 制定针对性的应对策略
5. 确定处理优先级和时间窗口
</think>

请对检测到的安全威胁进行深度分析，提供：
1. 威胁等级重新评估（低/中/高/严重）
2. 攻击向量分析和潜在影响
3. 具体可执行的修复建议
4. 紧急程度和处理时间窗口
5. 预防类似威胁的长期建议

请用中文回答，分析要深入透彻，建议要具体可行。"""
            
            user_prompt = f"请深度分析以下安全威胁：\n{threats_summary}"
            
            response = deepseek_client.chat.completions.create(
                model=os.getenv('DEEPSEEK_MODEL', 'deepseek-reasoner'),
                messages=[
                    {"role": "system", "content": system_prompt},
                    {"role": "user", "content": user_prompt}
                ],
                stream=False,
                temperature=0.1
            )
            
            ai_analysis = response.choices[0].message.content
            print("✅ AI深度分析完成")
            
            # 为每个威胁添加AI分析结果
            for threat in threats:
                threat['ai_analysis'] = ai_analysis
                
        except Exception as e:
            print(f"❌ AI分析失败: {e}")
        
        return threats
    
    def run_full_scan(self):
        """执行完整安全扫描"""
        print(f"🔍 [{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}] 开始执行增强版安全扫描...")
        
        all_threats = []
        
        # 1. 病毒扫描
        virus_threats = self.virus_scan()
        all_threats.extend(virus_threats)
        
        # 2. 端口扫描
        port_threats = self.port_scan()
        all_threats.extend(port_threats)
        
        # 3. 系统资源检查
        system_threats = self.system_resource_check()
        all_threats.extend(system_threats)
        
        # 4. 模拟SQL注入检测
        sql_threats = self.simulate_sql_injection_check()
        all_threats.extend(sql_threats)
        
        # 5. AI威胁分析
        if all_threats:
            all_threats = self.ai_analyze_threats(all_threats)
        
        # 记录扫描结果
        scan_result = {
            'timestamp': datetime.now().isoformat(),
            'threats_found': len(all_threats),
            'threats': all_threats,
            'scan_modules': ['病毒扫描', '端口扫描', '系统资源监控', 'SQL注入检测', 'AI威胁分析']
        }
        
        # 保存到Redis
        redis_client.lpush("scan_results", json.dumps(scan_result, ensure_ascii=False))
        redis_client.ltrim("scan_results", 0, 99)  # 保留最近100次扫描结果
        
        # 发送告警
        for threat in all_threats:
            self.send_alarm(threat)
        
        print(f"✅ 扫描完成，发现 {len(all_threats)} 个威胁")
        return all_threats
    
    def send_alarm(self, threat):
        """发送告警到告警服务"""
        try:
            alarm_data = {
                'level': threat['level'],
                'type': threat['type'],
                'details': threat['details']
            }
            
            # 如果有AI分析结果，添加到详情中
            if 'ai_analysis' in threat:
                alarm_data['details'] += f"\n\n🤖 AI分析:\n{threat['ai_analysis']}"
            
            response = requests.post(
                f"{ALARM_SERVICE_URL}/send-alarm",
                json=alarm_data,
                timeout=10
            )
            
            if response.status_code == 200:
                print(f"✅ 告警发送成功: {threat['type']}")
            else:
                print(f"❌ 告警发送失败: {response.text}")
                
        except Exception as e:
            print(f"❌ 发送告警时出错: {e}")

# 全局扫描器实例
scanner = SecurityScanner()

@app.route('/', methods=['GET'])
def index():
    """根路径接口"""
    return json_response({
        "service": "DeepGuard 增强版安全扫描服务",
        "version": "2.0.0", 
        "status": "运行中",
        "timestamp": datetime.now().isoformat(),
        "endpoints": {
            "健康检查": "/health",
            "手动扫描": "/scan (POST)",
            "扫描结果": "/scan-results",
            "更新病毒库": "/update-virus-db (POST)",
            "病毒扫描": "/virus-scan (POST)"
        },
        "description": "DeepGuard 安全检测系统的增强版扫描服务 - 集成ClamAV杀毒和AI分析",
        "scan_modules": [
            "ClamAV病毒扫描",
            "端口扫描",
            "系统资源监控", 
            "进程监控",
            "SQL注入检测",
            "DeepSeek AI威胁分析"
        ],
        "features": [
            "定时病毒扫描",
            "自动病毒库更新",
            "AI智能威胁分析",
            "多维度安全检测"
        ],
        "encoding": "UTF-8",
        "charset": "utf-8"
    })

@app.route('/health', methods=['GET'])
def health_check():
    """健康检查接口"""
    clamav_status = "已连接" if scanner.clamd_client else "未连接"
    ai_status = "已启用" if deepseek_client else "未启用"
    
    return json_response({
        "status": "健康",
        "service": "enhanced-security-scanner",
        "timestamp": datetime.now().isoformat(),
        "description": "增强版安全扫描服务运行正常",
        "components": {
            "ClamAV": clamav_status,
            "DeepSeek AI": ai_status,
            "Redis": "已连接",
            "端口扫描": "正常",
            "系统监控": "正常"
        }
    })

@app.route('/scan', methods=['POST'])
def manual_scan():
    """手动触发完整扫描"""
    try:
        threats = scanner.run_full_scan()
        return json_response({
            "success": True,
            "message": "增强版扫描完成",
            "threats_found": len(threats),
            "threats": threats,
            "scan_modules": ['病毒扫描', '端口扫描', '系统资源监控', 'SQL注入检测', 'AI威胁分析']
        })
    except Exception as e:
        return json_response({
            "success": False,
            "error": f"扫描失败: {str(e)}"
        }, 500)

@app.route('/virus-scan', methods=['POST'])
def manual_virus_scan():
    """手动触发病毒扫描"""
    try:
        threats = scanner.virus_scan()
        return json_response({
            "success": True,
            "message": "病毒扫描完成",
            "threats_found": len(threats),
            "threats": threats
        })
    except Exception as e:
        return json_response({
            "success": False,
            "error": f"病毒扫描失败: {str(e)}"
        }, 500)

@app.route('/update-virus-db', methods=['POST'])
def manual_update_virus_db():
    """手动更新病毒库"""
    try:
        success = scanner.update_virus_database()
        if success:
            return json_response({
                "success": True,
                "message": "病毒库更新成功"
            })
        else:
            return json_response({
                "success": False,
                "error": "病毒库更新失败"
            }, 500)
    except Exception as e:
        return json_response({
            "success": False,
            "error": f"病毒库更新异常: {str(e)}"
        }, 500)

@app.route('/scan-results', methods=['GET'])
def get_scan_results():
    """获取扫描结果历史"""
    try:
        limit = int(request.args.get('limit', 10))
        results = redis_client.lrange("scan_results", 0, limit - 1)
        
        records = []
        for result in results:
            records.append(json.loads(result))
        
        return json_response({
            "success": True,
            "message": "获取扫描结果成功",
            "data": records,
            "total": len(records)
        })
    except Exception as e:
        return json_response({
            "success": False,
            "error": f"获取扫描结果失败: {str(e)}"
        }, 500)

def scheduled_scan():
    """定时扫描任务"""
    scanner.run_full_scan()

def scheduled_virus_db_update():
    """定时病毒库更新任务"""
    scanner.update_virus_database()

def run_scheduler():
    """运行定时任务调度器"""
    # 定时扫描 (可配置频率)
    scan_interval = int(os.getenv('VIRUS_SCAN_INTERVAL', 60))  # 默认60分钟
    schedule.every(scan_interval).minutes.do(scheduled_scan)
    
    # 定时更新病毒库 (可配置频率)
    update_interval = int(os.getenv('VIRUS_DB_UPDATE_INTERVAL', 6))  # 默认6小时
    schedule.every(update_interval).hours.do(scheduled_virus_db_update)
    
    print(f"📅 定时任务已配置:")
    print(f"   - 病毒扫描: 每 {scan_interval} 分钟")
    print(f"   - 病毒库更新: 每 {update_interval} 小时")
    
    while True:
        schedule.run_pending()
        time.sleep(60)

if __name__ == '__main__':
    # 启动定时任务线程
    scheduler_thread = threading.Thread(target=run_scheduler, daemon=True)
    scheduler_thread.start()
    
    print("🚀 启动 DeepGuard 增强版安全扫描服务...")
    print("🦠 集成 ClamAV 杀毒引擎")
    print("🤖 集成 DeepSeek AI 威胁分析")
    app.run(host='0.0.0.0', port=19563, debug=False)